/**
 * Created by hanj on 2022/6/9 17:13
 */
package com.example.miniotest;

import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import io.minio.*;
import io.minio.errors.MinioException;
import io.minio.http.Method;
import io.minio.messages.*;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;


import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

import java.io.InputStream;
import java.nio.charset.StandardCharsets;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * minIO工具类
 */
@Slf4j
public class MinIOUtils {

    private PearlMinIOClient minioClient;

    /**
     * 失效时间
     */
    private final Integer expires = 60 * 60 * 24;

    public MinIOUtils(PearlMinIOClient minioClient) {
        this.minioClient = minioClient;
    }


    /**
     * 创建新存储桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        try {
            // 如存储桶不存在，创建之。
            BucketExistsArgs bucket = BucketExistsArgs.builder().bucket(bucketName).build();
            boolean found = minioClient.bucketExists(bucket);
            if (found) {
                log.info("{} already exists", bucketName);
            } else {
                // 创建存储桶。
                MakeBucketArgs makeBucketArgs = MakeBucketArgs.builder().bucket(bucketName).build();
                minioClient.makeBucket(makeBucketArgs);
                log.info("{} is created successfully", bucketName);
            }
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 获取所有桶的列表
     *
     * @return 桶集合
     */
    @SneakyThrows
    public List<Bucket> listBucket() {
        try {
            // 列出所有存储桶
            List<Bucket> bucketList = minioClient.listBuckets();
            for (Bucket bucket : bucketList) {
                log.info("{},{}", bucket.creationDate(), bucket.name());
            }
            return bucketList;
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 检查存储桶是否存在
     *
     * @param bucketName 桶名称
     * @return 响应值
     */
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        try {
            // 检查'my-bucketname'是否存在。
            boolean found = minioClient.bucketExists(
                    BucketExistsArgs.builder().bucket(bucketName).build());
            if (found) {
                log.info("{} exists", bucketName);
            } else {
                log.info("{} does not exist", bucketName);
            }
            return found;
        } catch (MinioException e) {
            log.error("Error occurred: {}" + e.getMessage());
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除一个存储桶。
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public Boolean removeBucket(String bucketName) {
        try {
            // 删除之前先检查`my-bucket`是否存在。
            boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (found) {
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    // 有对象文件，则删除失败
                    if (item.size() > 0) {
                        return false;
                    }
                }
                // 删除`my-bucketname`存储桶，注意，只有存储桶为空时才能删除成功。
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
                log.info("{} is removed successfully", bucketName);
                return true;
            } else {
                log.info("{} does not exist", bucketName);
                return false;
            }
        } catch (MinioException e) {
            log.error("Error occurred: {}" + e.getMessage());
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 列出某个存储桶中的所有对象。
     *
     * @param bucketName  桶名称
     * @param prefix      对象名称的前缀
     * @param recursive   是否递归查找，如果是false,就模拟文件夹结构查找。
     * @param useVersion1 如果是true, 使用版本1 REST API
     * @return 某个桶中所有对象
     */
    @SneakyThrows
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix, boolean recursive, boolean useVersion1) {
        try {
            // 检查'mybucket'是否存在。
            boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (found) {
                // 列出'my-bucketname'里的对象
                Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().
                        bucket(bucketName).prefix(prefix).recursive(recursive).useApiVersion1(useVersion1).build());
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    log.info(item.lastModified() + ", " + item.size() + ", " + item.objectName());
                }
                return myObjects;
            } else {
                log.info("{} does not exist", bucketName);
            }
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 以流的形式下载一个对象
     *
     * @param bucketName 桶名称
     * @param objectName 存储桶里的对象名称
     * @return 流对象
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        InputStream stream = null;
        try {
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());

            // 获取"myobject"的输入流。
            stream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());

            // 读取输入流直到EOF并打印到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                //写入文件
                log.info(new String(buf, 0, bytesRead));
            }
            return stream;
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            // 关闭流，此处为示例，流关闭最好放在finally块。
            assert stream != null;
            stream.close();
        }
    }

    /**
     * 下载对象指定区域的字节数组做为流。（断点下载）
     *
     * @param bucketName 桶名称
     * @param objectName 桶内文件名称
     * @param offset     是起始字节的位置
     * @param length     是要读取的长度 (可选，如果无值则代表读到文件结尾)。
     * @return InputStream 流对象
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName, long offset, Long length) {
        InputStream stream = null;
        try {
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(StatObjectArgs.builder().
                    bucket(bucketName).object(objectName).build());

            // 获取指定offset和length的"myobject"的输入流。
            stream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).
                    object(objectName).
                    offset(offset).
                    length(length).build());

            // 读取输入流直到EOF并打印到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                log.info(new String(buf, 0, bytesRead));
            }
            return stream;
        } catch (MinioException e) {
            log.error("Error occurred: {}" + e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            // 关闭流。
            assert stream != null;
            stream.close();
        }

    }

    /**
     * 在给定的存储桶中获取整个加密对象的数据作为InputStream，
     * <p>
     * 然后用传入的master keyPair解密和加密对象关联的content key。
     * 然后创建一个含有InputStream和Cipher的CipherInputStream。
     * 这个Cipher被初始为用于使用content key进行解密，所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。
     * 所以read()方法返回的是处理过的原始对象数据。
     *
     * @param bucketName 桶名称
     * @param objectName 桶内对象名称
     * @param symKey     加密key
     * @return
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName, SecretKey symKey) {
        InputStream stream = null;
        try {
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());

            //生成256位AES key。
            KeyGenerator symKeyGenerator = KeyGenerator.getInstance("AES");
            symKeyGenerator.init(256);
            symKey = symKeyGenerator.generateKey();

            stream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).ssec((ServerSideEncryptionCustomerKey) symKey).build());

            // 读流到EOF，并输出到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                System.out.println(new String(buf, 0, bytesRead, StandardCharsets.UTF_8));
            }
            return stream;
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            // 关闭流。
            assert stream != null;
            stream.close();
        }
    }

    /**
     * 通过文件上传到对象中
     *
     * @param bucketName 桶名称
     * @param objectName 桶内对象名称
     * @param fileName   文件名称
     */
    @SneakyThrows
    public void uploadObject(String bucketName, String objectName, String fileName) {
        try {
            minioClient.uploadObject(UploadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build());
            log.info("{} is uploaded successfully", bucketName);
        } catch (MinioException e) {
            log.info("Error occurred: {}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 获取对象的元数据
     *
     * @param bucketName 桶名称
     * @param objectName 桶内文件名
     * @return
     */
    @SneakyThrows
    public StatObjectResponse statObject(String bucketName, String objectName) {
        try {
            // 获得对象的元数据。
            StatObjectResponse statObject = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
            log.info(statObject.toString());
            return statObject;
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 删除一个对象
     *
     * @param bucketName 桶名称
     * @param objectName 桶内对象名称
     */
    @SneakyThrows
    public void removeObject(String bucketName, String objectName) {
        try {
            // 从mybucket中删除myobject。
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
            log.info("successfully removed {}/{}", bucketName, objectName);
        } catch (MinioException e) {
            log.error("Error: {}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 删除多个对象。
     *
     * @param bucketName  桶名称
     * @param objectNames 桶内对象名称
     * @return
     */
    @SneakyThrows
    public Iterable<Result<DeleteError>> removeObject(String bucketName, Iterable<DeleteObject> objectNames) {
        try {
            // 删除my-bucketname里的多个对象
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objectNames).build());
            for (Result<DeleteError> errorResult : results) {
                DeleteError error = errorResult.get();
                log.info("Failed to remove {}. Error:{}", error.objectName(), error.message());
            }
            return results;
        } catch (MinioException e) {
            log.error("Error: {}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取文件Get下载地址
     * <p>
     * 生成一个给HTTP GET请求用的presigned URL。
     * 浏览器/移动端的客户端可以用这个URL进行下载，即使其所在的存储桶是私有的。
     * 这个presigned URL可以设置一个失效时间，默认值是7天
     *
     * @param bucketName 桶名称
     * @param objectName 桶内对象名称
     * @return 返回下载地址
     */
    @SneakyThrows
    public String presignedGetObject(String bucketName, String objectName) {
        try {
            String url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().
                    bucket(bucketName).object(objectName).expiry(expires).method(Method.GET).build());
            log.info(url);
            return url;
        } catch (MinioException e) {
            log.error("Error occurred: {}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 返回临时带签名、过期时间一天、Get请求方式的访问URL
     *
     * @param bucketName  桶名
     * @param ossFilePath Oss文件路径
     * @return
     */
    @SneakyThrows
    public String getPresignedObjectUrl(String bucketName, String ossFilePath, Map<String, String> queryParams) {
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.PUT)
                        .bucket(bucketName)
                        .object(ossFilePath)
                        .expiry(expires)
                        .extraQueryParams(queryParams)
                        .build());
    }


    /**
     * 列出所有存储桶名称
     *
     * @return
     */
    @SneakyThrows
    public List<String> listBucketNames() {
        List<Bucket> list = listBuckets();
        return list.stream().filter(Objects::nonNull).map(Bucket::name).collect(Collectors.toList());
    }

    /**
     * 列出所有存储桶
     *
     * @return
     */
    @SneakyThrows
    public List<Bucket> listBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 列出存储桶中的所有对象
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public Iterable<Result<Item>> listObjects(String bucketName) {
        return minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public List<String> listObjectNames(String bucketName) {
        List<String> ret = Lists.newArrayList();
        Iterable<Result<Item>> myObjects = listObjects(bucketName);
        for (Result<Item> result : myObjects) {
            Item item = result.get();
            ret.add(item.objectName());
        }
        return ret;
    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param multipartFile
     */
    @SneakyThrows
    public ObjectWriteResponse putObject(String bucketName, MultipartFile multipartFile) {
        PutObjectArgs args = PutObjectArgs.builder()
                .bucket(bucketName)
                .object(multipartFile.getName())
                .contentType(multipartFile.getContentType())
                .stream(multipartFile.getInputStream(), multipartFile.getSize(), -1)
                .build();
        return minioClient.putObject(args);
    }

    /**
     * 通过InputStream上传对象
     *
     * @param bucketName  存储桶名称
     * @param objectName  存储桶里的对象名称
     * @param in          要上传的流
     * @param contentType 要上传的文件类型 MimeTypeUtils.IMAGE_JPEG_VALUE
     * @return
     */
    @SneakyThrows
    public ObjectWriteResponse putObject(String bucketName, String objectName, InputStream in, String contentType) {
        PutObjectArgs args = PutObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .contentType(contentType)
                .stream(in, in.available(), -1)
                .build();
        return minioClient.putObject(args);
    }

    /**
     * 上传分片上传请求，返回uploadId
     */

    @SneakyThrows
    public CreateMultipartUploadResponse uploadId(String bucketName, String region, String objectName, Multimap<String, String> headers, Multimap<String, String> extraQueryParams) {
        return minioClient.createMultipartUpload(bucketName, region, objectName, headers, extraQueryParams);
    }

    /**
     * 创建分片上传请求
     *
     * @param bucketName       存储桶
     * @param region           区域
     * @param objectName       对象名
     * @param headers          消息头
     * @param extraQueryParams 额外查询参数
     */
    @SneakyThrows
    public CreateMultipartUploadResponse createMultipartUpload(String bucketName, String region, String objectName, Multimap<String, String> headers, Multimap<String, String> extraQueryParams) {
        return minioClient.createMultipartUpload(bucketName, region, objectName, headers, extraQueryParams);
    }

    /**
     * 完成分片上传，执行合并文件
     *
     * @param bucketName       存储桶
     * @param region           区域
     * @param objectName       对象名
     * @param uploadId         上传ID
     * @param parts            分片
     * @param extraHeaders     额外消息头
     * @param extraQueryParams 额外查询参数
     */
    @SneakyThrows
    public ObjectWriteResponse completeMultipartUpload(String bucketName, String region, String objectName, String uploadId, Part[] parts, Multimap<String, String> extraHeaders, Multimap<String, String> extraQueryParams) {
        return minioClient.completeMultipartUpload(bucketName, region, objectName, uploadId, parts, extraHeaders, extraQueryParams);
    }

    /**
     * 查询分片数据
     *
     * @param bucketName       存储桶
     * @param region           区域
     * @param objectName       对象名
     * @param uploadId         上传ID
     * @param extraHeaders     额外消息头
     * @param extraQueryParams 额外查询参数
     */
    @SneakyThrows
    public ListPartsResponse listMultipart(String bucketName, String region, String objectName, Integer maxParts, Integer partNumberMarker, String uploadId, Multimap<String, String> extraHeaders, Multimap<String, String> extraQueryParams) {
        return minioClient.listMultipart(bucketName, region, objectName, maxParts, partNumberMarker, uploadId, extraHeaders, extraQueryParams);
    }

}
